#region License
// ----------------------------------------------------------------------
// XcoBinarySerializer.cs
// 
// This file is part of the XcoAppSpace package which is developed 
// and licensed by www.xcoordination.org. 
//
// Copyright (C) 2009: Markus Karolus, Thomas Scheller, Ralf Westphal
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
// or  http://www.gnu.org/licenses/gpl-2.0.html.
//
// Linking this library statically or dynamically with other modules is
// making a combined work based on this library.  Thus, the terms and
// conditions of the GNU General Public License cover the whole
// combination.
// 
// As a special exception, the copyright holders of this library give you
// permission to link this library with independent modules to produce an
// executable, regardless of the license terms of these independent
// modules, and to copy and distribute the resulting executable under
// terms of your choice, provided that you also meet, for each linked
// independent module, the terms and conditions of the license of that
// module.  An independent module is a module which is not derived from
// or based on this library.  If you modify this library, you may extend
// this exception to your version of the library, but you are not
// obligated to do so. If you do not wish to do so, delete this
// exception statement from your version.
// ----------------------------------------------------------------------
#endregion

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Text;
using System.Xml;
using System.Runtime.Serialization.Formatters.Binary;
using XcoAppSpaces.Contracts.Service;
using XcoAppSpaces.Contracts.Transport;
using System.IO;
using XcoAppSpaces.Contracts.Serialization;

namespace test.XcoAppSpaces.Core.Communication
{
	/// <summary>
	/// Helper class for serialization and deserialization of objects (used in
    /// communication with remote spaces). Uses the BinaryFormatter.
	/// </summary>
    public class BinarySerializerMock : IXcoSerializer
	{
       private readonly BinaryFormatter ser = new BinaryFormatter();

		/// <summary>
		/// Sets the surrogate selector for the serializer (needed for special serialization/deserialization rules)
		/// </summary>
		/// <param name="surrogateSelector">The ISurrogateSelector that should be used.</param>
		public void SetSurrogateSelector(ISurrogateSelector surrogateSelector)
		{
			ser.SurrogateSelector = surrogateSelector;
		}

		/// <summary>
		/// Serializes an object into a byte array.
		/// </summary>
		/// <param name="element">The object to be serialized.</param>
		/// <returns>The serialized object.</returns>
		public byte[] Serialize(object element)
		{
			using (System.IO.MemoryStream elementStream = new System.IO.MemoryStream())
			{                
                ser.Serialize(elementStream, element);
                
                elementStream.Position = 0;
                byte[] data = new byte[elementStream.Length];
                elementStream.Read(data, 0, data.Length);
                
                return data;
			}
		}

		

		/// <summary>
		/// Deserializes an object from a byte array.
		/// </summary>
		/// <param name="element">The serialized object.</param>
		/// <returns>The object that has been deserialized.</returns>
		public object Deserialize(byte[] element)
        {
               using (System.IO.MemoryStream elementStream = new System.IO.MemoryStream(element))
                {
                    return Deserialize(elementStream);
                }
        
        }

        /// <summary>
        /// Deserializes an object from a byte array.
        /// </summary>
        /// <param name="stream">The serialized object.</param>
        /// <returns>The object that has been deserialized.</returns>
        public object Deserialize(Stream stream)
        {          
            return ser.Deserialize(stream);            
        }

		public void Initialize(IXcoServiceRegistry serviceRegistry)
		{
		}

		public bool CanTypeBeSerialized(Type type, out string errorInfo)
		{
			errorInfo = null;
			return true;
		}
	}
}
